Developer CD Series 1998 August: Tool Chest/Dev.CD Aug 98 TC.toast/Tool Chest/Testing & Debugging/Virtual User/Virtual User Current Release/Examples/External Tool Templates/CPlus Tool Template/List.cp

Text File | 1998-06-04 | 7.9 KB | 400 lines | [TEXT/MPS ]

/*
 *    File:        List.cp
 *
 *    Contains:    xxx put contents here xxx
 *
 *    Written by:    Rick Violet
 *
 *    Copyright:    © 1992 by Apple Computer, Inc., all rights reserved.
 *
 *    Change History (most recent first):
 *
 *                11/18/92    RV        xxx put comment here xxx
 *
 *    To Do:
 */

//—————————————————————————————————————————————————————————————
#include "List.h"

#ifndef __TYPES__
#include <Types.h>
#endif

#ifndef __MEMORY__
#include <Memory.h>
#endif


//******************************************************************************
//——————————————————————————————————————————————————————————————————————————————
ListNode::ListNode( Object* pObject )
{
    fNextNode = nil;
    fPrevNode = nil;
    fNodeObject = pObject;
}

//——————————————————————————————————————————————————————————————————————————————
ListNode::~ListNode(void)
{
}

//******************************************************************************
//——————————————————————————————————————————————————————————————————————————————
List::List(void)
{
    fFirstNode = nil;
    fLastNode = nil;
    fCount = 0;
}

//——————————————————————————————————————————————————————————————————————————————
List::~List(void)
{
}

//——————————————————————————————————————————————————————————————————————————————
void
List::AddAsFirst( Object* pObject )
{
    ListNode*    tNode = new ListNode( pObject );

    if( !tNode )
    {
        return;
    }

    if( fFirstNode == nil )
    {
        fFirstNode = tNode;
        fLastNode = tNode;
        tNode->SetNext( nil );
        tNode->SetPrev( nil );
    }
    else
    {
        fFirstNode->SetPrev( tNode );
        tNode->SetNext( fFirstNode );
        tNode->SetPrev( nil );
        fFirstNode = tNode;
    }
    fCount++;
}

//——————————————————————————————————————————————————————————————————————————————
void
List::AddAsLast( Object* pObject )
{
    ListNode*    tNode = new ListNode( pObject );
    if( !tNode )
    {
        return;
    }

    if( fFirstNode == nil )
    {
        fFirstNode = tNode;
        fLastNode = tNode;
        tNode->SetNext( nil );
        tNode->SetPrev( nil );
    }
    else
    {
        fLastNode->SetNext( tNode );
        tNode->SetNext( nil );
        tNode->SetPrev( fLastNode );
        fLastNode = tNode;
    }
    fCount++;
}

//——————————————————————————————————————————————————————————————————————————————
void
List::Insert( Object* pObject, short pIndex )
{
    ListNode*     tLeadingNode;
    ListNode*     tFollowingNode;
    ListNode*    tNode;
    ListNode*    tTheNode;

    tTheNode = new ListNode( pObject );        //———— Make new node containing pObject
    if( !tTheNode )
    {
        return;
    }


    if( fFirstNode == nil )                    //———— Is the list empty?
    {
        fFirstNode = tTheNode;                //———— the list is empty
        fLastNode = tTheNode;                //———— put the new node in and exit
        fCount = 1;
        return;
    }
                                            //————    The list is not empty
    if( pIndex <= 0 )                        //————    Is pIndex zero or negative?
    {
        tLeadingNode = fLastNode;            //————    pIndex is zero or negative
        tFollowingNode = nil;                //————    add to the end of the list
    }
    else
    {
        tNode = fFirstNode;                    //———— advance tNode down the list
                                            //———— until indexed node is found
        for( short i = 1; i < pIndex; i++ )
        {
            if( !tNode )                     //———— pIndex beyond last node?
            {
                tLeadingNode = fLastNode;    //———— reached the end of the list
                tFollowingNode = nil;        //———— before indexed node was found
                break;                        //———— append to list as default
            }
            else
            {
                tNode = tNode->GetNext();    //———— advance tNode to the next node
            }
        }
        tLeadingNode = tNode->GetPrev();    //———— setup to bump indexed node down and
        tFollowingNode = tNode;                //———— put the new node at indexed position

    }

    if( tLeadingNode )                        //———— link with preceding node
    {
        tLeadingNode->SetNext( tTheNode );
    }

    tTheNode->SetPrev( tLeadingNode );

    if( tFollowingNode )                    //———— link with following node
    {
        tFollowingNode->SetPrev( tTheNode );
    }
    tTheNode->SetNext( tFollowingNode );

    if( tFollowingNode == fFirstNode )        //———— reassign fFirstNode if needed
    {
        fFirstNode = tTheNode;
    }
    else
    {
        if( tLeadingNode == fLastNode )        //———— reassign fLastNode if needed
        {
            fLastNode = tTheNode;
        }
    }
    fCount++;                                //———— keep track of how many nodes
}

//——————————————————————————————————————————————————————————————————————————————
void
List::Remove( Object* pObject )
{
    ListNode* tNode;
    ListNode* tTheNode;

     tTheNode = FindNode( pObject );
    if( tTheNode )
    {
        tNode = tTheNode->GetPrev();
        if( tNode )    // remove from forward chain
        {
            tNode->SetNext( tTheNode->GetNext() );
        }

        tNode = tTheNode->GetNext();
        if( tNode )    // remove from backward chain
        {
            tNode->SetPrev( tTheNode->GetPrev() );
        }

        if( fFirstNode == tTheNode )        // are we removing the first node?
        {
            if( fLastNode == tTheNode )        // and the last node?
            {
                fFirstNode = nil;            // then make the list empty
                fLastNode = nil;
            }
            else                            // we're removing only the first node
            {
                fFirstNode = tTheNode->GetNext();
            }
        }
        else                                // we're not removing the first node
        {
            if( fLastNode == tTheNode )        // are we removing the last node?
            {
                fLastNode = tTheNode->GetPrev();
            }
        }
        delete tTheNode;
        fCount--;
    }
}

//——————————————————————————————————————————————————————————————————————————————
void
List::RemoveAll(void)
{
    ListNode*    tNode2;
    ListNode*    tNode;

    tNode = fFirstNode;
    if( tNode )
    {
        do
        {
            tNode2 = tNode->GetNext();
            delete tNode;
            tNode = tNode2;
        }
        while( tNode );

        fFirstNode = nil;
        fLastNode = nil;
        fCount = 0;
    }
}

//——————————————————————————————————————————————————————————————————————————————
void
List::DisposeAll(void)
{
    Object*            tObject;
    ListNode*        tNode2;
    ListNode*        tNode;

    tNode = fFirstNode;
    if( tNode )
    {
        do
        {
            tNode2 = tNode->GetNext();
            tObject = tNode->GetNodeObject();
            delete tObject;
            delete tNode;
            tNode = tNode2;
        }
        while( tNode );
        fCount = 0;
    }
}

//——————————————————————————————————————————————————————————————————————————————
ListNode*
List::FindNode( Object* pObject )
{
    ListNode*    tNode;

     tNode = fFirstNode;
    if( tNode )                        // Start with the first node
    {
        do                                            // Loop through each node
        {
            if( tNode->GetNodeObject() == pObject )    // return the found node
            {
                return tNode;
            }
            tNode = tNode->GetNext();
        }
        while( tNode );
    }
    return nil;                                        // return nil if not found
}

//——————————————————————————————————————————————————————————————————————————————
short
List::GetIndexOf( Object* pObject )
{
    ListNode*    tNode;
    short        tIndex;

    tNode = fFirstNode;
    if( tNode )                        // Start with the first node
    {
        tIndex = 0;
        do                                            // Loop through each node
        {
            if( tNode->GetNodeObject() == pObject )    // return the found node
            {
                return tIndex;
            }
            tIndex++;
            tNode = tNode->GetNext();
        }
        while( tNode );
    }
    return -1;                                        // return -1 if not found
}

//——————————————————————————————————————————————————————————————————————————————
Object*
List::GetFirst(void)
{
    if( fFirstNode )
    {
        return fFirstNode->GetNodeObject();
    }
    else
    {
        return nil;
    }
}

//——————————————————————————————————————————————————————————————————————————————
Object*
List::GetIndexed( short pIndex )
{
    ListNode*    tNode = fFirstNode;
    for( short i = 0; i < pIndex; i++ )
    {
        if( !tNode )
        {
            return nil;
        }
        tNode = tNode->GetNext();
    }
    return tNode->GetNodeObject();
}

//******************************************************************************
//——————————————————————————————————————————————————————————————————————————————
Loop::Loop( List* pList )
{
    fList = pList;
    fCurrNode = pList->GetFirstNode();
}

//——————————————————————————————————————————————————————————————————————————————
Loop::~Loop()
{
}

//——————————————————————————————————————————————————————————————————————————————
void
Loop::Reset( List* pList = nil )
{
    if( pList )
    {
        fList = pList;
    }
    fCurrNode = fList->GetFirstNode();
}

//——————————————————————————————————————————————————————————————————————————————
Object*
Loop::GetNext(void)
{
    ListNode*    tNode;

    if( fCurrNode == nil )
    {
        return nil;
    }

    tNode = fCurrNode;
    fCurrNode = fCurrNode->GetNext();
    return tNode->GetNodeObject();
}